package com.cfets.annualAssessment.util;

import javassist.bytecode.stackmap.BasicBlock;
import jdk.nashorn.internal.ir.CatchNode;
import org.apache.http.impl.cookie.PublicSuffixDomainFilter;
import org.springframework.data.keyvalue.annotation.KeySpace;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;

import javax.xml.crypto.dsig.keyinfo.RetrievalMethod;
import java.rmi.server.ExportException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author DavidSun
 * @create 2019-01-04 16:14
 * @desc RedisUtil配置
 **/
public class RedisUtil {
    private RedisTemplate<String,Object> redisTemplate;

    public  void setRedisTemplate(RedisTemplate<String,Object> redisTemplate){
        this.redisTemplate = redisTemplate;
    }
    // 指定缓存失效时间
    public  boolean exprie(String key, long time){
        try{
            if(time>0){
                redisTemplate.expire(key,time,TimeUnit.SECONDS);
            }
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    //根据key获取过期时间
    public  long getExprie(String key ){
        return  redisTemplate.getExpire(key);
    }

    // 判断key是否存在
    public  boolean hasKey(String key){
        try{
            return  redisTemplate.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    // 删除缓存
    public  void del(String ... key){
        if (key!=null && key.length>0){
            if (key.length ==1){
                redisTemplate.delete(key[0]);
            }else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    // 普通缓存获取
    public  Object get(String key){
        return  key==null?null:redisTemplate.opsForValue().get(key);
    }

    // 普通缓存存入
    public  boolean set (String key, Object value){
        try{
            redisTemplate.opsForValue().set(key,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    //普通缓存放入并设置时间

    public  boolean set(String key ,Object value,long time){
        try{
            if (time>0){
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else {
                set(key,value);

            }
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    //递增
    public  long incr(String key,long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return  redisTemplate.opsForValue().increment(key,delta);
    }

    //递减
    public  long decr(String key ,long delta){
        if (delta<0){
            throw  new RuntimeException("递减因子必须大于0");
        }
        return  redisTemplate.opsForValue().increment(key,-delta);
    }

    //HashSet
    public  Object hget(String key,String item){
        return  redisTemplate.opsForHash().get(key,item);
    }

    //获取hashkey所对应的所有的值
    public Map<Object,Object> hmget(String key){
        return  redisTemplate.opsForHash().entries(key);
    }

    // HashSet  设置值

    public boolean hmset(String key, Map<String,Object> map){
        try{
            redisTemplate.opsForHash().putAll(key,map);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    //HashSet 设置时间
    public  boolean hmset(String key ,Map<String,Object> map,long time){
        try{
            redisTemplate.opsForHash().putAll(key,map);
            if (time>0){
                exprie(key,time);
            }
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    // 向一张hash表中存放数据，如果不存在则将创建
    public  boolean hset(String key ,String itme, Object value)
    {
        try{
            redisTemplate.opsForHash().put(key,itme,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    // 向一张hash表中存放数据，在时间规定的范围内如果不存在则将创建
    public  boolean hset(String key,String item, Object value, long time){
        try {
            redisTemplate.opsForHash().put(key,item,value);
            if (time>0){
                exprie(key,time);
            }
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    // 判断hash表中是否有值
    public  boolean hHashKey(String key ,String item){
        return  redisTemplate.opsForHash().hasKey(key,item);
    }

    //hash递增，如果不存在  ，就会创建一个并把新增后的值返回
    public  Double hincr(String key,String item ,double by){
        return  redisTemplate.opsForHash().increment(key,item,by);
    }

    //hash递减
    public  Double hdecr(String key,String item,double by){
        return  redisTemplate.opsForHash().increment(key,item,-by);
    }

    //根据key获取set中的所有值
    public Set<Object> sGet(String key ){
        try{
            return  redisTemplate.opsForSet().members(key);
        }catch (Exception e){
            e.printStackTrace();
            return  null;

        }
    }

    // 根据value 从set中查询，是否存在
    public  boolean sHashKey(String key,Object value){
        try {
            return  redisTemplate.opsForSet().isMember(key,value);
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    // 将数据放到set缓存中
    public  long sSet(String key,Object ... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;

        }

    }
    //将set数据放到缓存中
    public  long sSetAndTime(String key,long time,Object ... values){
        try{
            Long count = redisTemplate.opsForSet().add(key,values);
            if (time>0){
                exprie(key,time);
            }
            return  count;
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }

    //获取set缓存长度
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForZSet().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }

    // 移除值为value的.个数
    public  long setRemove(String key,Object ... values){
        try {
            Long count = redisTemplate.opsForZSet().remove(key,values);
            return  count;
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }


    // 获取list的内容
    public List<Object> lGet(String key,long start ,long end){
        try{
            return  redisTemplate.opsForList().range(key,start,end);
        }catch (Exception e){
            e.printStackTrace();
            return  null;
        }
    }

    // 获取list长度
    public  long lGetListSize(String  key){
        try {
            return  redisTemplate.opsForList().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }


    //通过索引，获取list的值
    public  Object lGetIndex(String key ,long index){
        try{
                return redisTemplate.opsForList().index(key,index);
        }catch (Exception e){
            e.printStackTrace();
            return  null;
        }
    }


    // 将list放到缓存中
    public  boolean lSet(String key ,Object value){
        try{
            redisTemplate.opsForList().rightPush(key,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }


    //将list放到缓存中
    public  boolean lSet(String key,Object value,long time){
        try {
            redisTemplate.opsForList().rightPush(key,value);
            if (time>0){
                exprie(key,time);
            }
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    //将list放到缓存中
    public  boolean lSet(String key,List<Object> value){
        try {
            redisTemplate.opsForList().rightPushAll(key,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }


    // 根据索引修改list中某条数据
    public  boolean lUpdateIndex(String key, long  index, Object value){
        try{
            redisTemplate.opsForList().set(key,index,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    // 移除N个为 值为value
    public  long lRemove(String key,long count ,Object value){
        try {
            return  redisTemplate.opsForList().remove(key,count,value);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }
}
